/** @file
 *    @brief MAVLink comm protocol testsuite generated from x_autopilot.xml
 *    @see http://qgroundcontrol.org/mavlink/
 */
#pragma once
#ifndef X_AUTOPILOT_TESTSUITE_H
#define X_AUTOPILOT_TESTSUITE_H

#ifdef __cplusplus
extern "C" {
#endif

#ifndef MAVLINK_TEST_ALL
#define MAVLINK_TEST_ALL
static void mavlink_test_common(uint8_t, uint8_t, mavlink_message_t *last_msg);
static void mavlink_test_x_autopilot(uint8_t, uint8_t, mavlink_message_t *last_msg);

static void mavlink_test_all(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
{
    mavlink_test_common(system_id, component_id, last_msg);
    mavlink_test_x_autopilot(system_id, component_id, last_msg);
}
#endif

#include "../common/testsuite.h"


static void mavlink_test_xap_msg(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
{
#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
    mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
        if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_XAP_MSG >= 256) {
            return;
        }
#endif
    mavlink_message_t msg;
        uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
        uint16_t i;
    mavlink_xap_msg_t packet_in = {
        963497464,17
    };
    mavlink_xap_msg_t packet1, packet2;
        memset(&packet1, 0, sizeof(packet1));
        packet1.time_boot_ms = packet_in.time_boot_ms;
        packet1.field1 = packet_in.field1;
        
        
#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
        if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
           // cope with extensions
           memset(MAVLINK_MSG_ID_XAP_MSG_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_XAP_MSG_MIN_LEN);
        }
#endif
        memset(&packet2, 0, sizeof(packet2));
    mavlink_msg_xap_msg_encode(system_id, component_id, &msg, &packet1);
    mavlink_msg_xap_msg_decode(&msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);

        memset(&packet2, 0, sizeof(packet2));
    mavlink_msg_xap_msg_pack(system_id, component_id, &msg , packet1.time_boot_ms , packet1.field1 );
    mavlink_msg_xap_msg_decode(&msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);

        memset(&packet2, 0, sizeof(packet2));
    mavlink_msg_xap_msg_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_boot_ms , packet1.field1 );
    mavlink_msg_xap_msg_decode(&msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);

        memset(&packet2, 0, sizeof(packet2));
        mavlink_msg_to_send_buffer(buffer, &msg);
        for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
            comm_send_ch(MAVLINK_COMM_0, buffer[i]);
        }
    mavlink_msg_xap_msg_decode(last_msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
        
        memset(&packet2, 0, sizeof(packet2));
    mavlink_msg_xap_msg_send(MAVLINK_COMM_1 , packet1.time_boot_ms , packet1.field1 );
    mavlink_msg_xap_msg_decode(last_msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
}

static void mavlink_test_xap_aruco(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
{
#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
    mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
        if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_XAP_ARUCO >= 256) {
            return;
        }
#endif
    mavlink_message_t msg;
        uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
        uint16_t i;
    mavlink_xap_aruco_t packet_in = {
        963497464,45.0,73.0,101.0,129.0,157.0,185.0,213.0,101,168
    };
    mavlink_xap_aruco_t packet1, packet2;
        memset(&packet1, 0, sizeof(packet1));
        packet1.time_boot_ms = packet_in.time_boot_ms;
        packet1.x = packet_in.x;
        packet1.y = packet_in.y;
        packet1.z = packet_in.z;
        packet1.q0 = packet_in.q0;
        packet1.q1 = packet_in.q1;
        packet1.q2 = packet_in.q2;
        packet1.q3 = packet_in.q3;
        packet1.markerID = packet_in.markerID;
        packet1.isTarget = packet_in.isTarget;
        
        
#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
        if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
           // cope with extensions
           memset(MAVLINK_MSG_ID_XAP_ARUCO_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_XAP_ARUCO_MIN_LEN);
        }
#endif
        memset(&packet2, 0, sizeof(packet2));
    mavlink_msg_xap_aruco_encode(system_id, component_id, &msg, &packet1);
    mavlink_msg_xap_aruco_decode(&msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);

        memset(&packet2, 0, sizeof(packet2));
    mavlink_msg_xap_aruco_pack(system_id, component_id, &msg , packet1.time_boot_ms , packet1.markerID , packet1.x , packet1.y , packet1.z , packet1.q0 , packet1.q1 , packet1.q2 , packet1.q3 , packet1.isTarget );
    mavlink_msg_xap_aruco_decode(&msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);

        memset(&packet2, 0, sizeof(packet2));
    mavlink_msg_xap_aruco_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_boot_ms , packet1.markerID , packet1.x , packet1.y , packet1.z , packet1.q0 , packet1.q1 , packet1.q2 , packet1.q3 , packet1.isTarget );
    mavlink_msg_xap_aruco_decode(&msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);

        memset(&packet2, 0, sizeof(packet2));
        mavlink_msg_to_send_buffer(buffer, &msg);
        for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
            comm_send_ch(MAVLINK_COMM_0, buffer[i]);
        }
    mavlink_msg_xap_aruco_decode(last_msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
        
        memset(&packet2, 0, sizeof(packet2));
    mavlink_msg_xap_aruco_send(MAVLINK_COMM_1 , packet1.time_boot_ms , packet1.markerID , packet1.x , packet1.y , packet1.z , packet1.q0 , packet1.q1 , packet1.q2 , packet1.q3 , packet1.isTarget );
    mavlink_msg_xap_aruco_decode(last_msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
}

static void mavlink_test_xap_camera_target_info(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
{
#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
    mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
        if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_XAP_CAMERA_TARGET_INFO >= 256) {
            return;
        }
#endif
    mavlink_message_t msg;
        uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
        uint16_t i;
    mavlink_xap_camera_target_info_t packet_in = {
        963497464,963497672,963497880,963498088,963498296,65,132,199
    };
    mavlink_xap_camera_target_info_t packet1, packet2;
        memset(&packet1, 0, sizeof(packet1));
        packet1.time_boot_ms = packet_in.time_boot_ms;
        packet1.x_offset = packet_in.x_offset;
        packet1.y_offset = packet_in.y_offset;
        packet1.height = packet_in.height;
        packet1.width = packet_in.width;
        packet1.targetID = packet_in.targetID;
        packet1.do_rectify = packet_in.do_rectify;
        packet1.isTarget = packet_in.isTarget;
        
        
#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
        if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
           // cope with extensions
           memset(MAVLINK_MSG_ID_XAP_CAMERA_TARGET_INFO_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_XAP_CAMERA_TARGET_INFO_MIN_LEN);
        }
#endif
        memset(&packet2, 0, sizeof(packet2));
    mavlink_msg_xap_camera_target_info_encode(system_id, component_id, &msg, &packet1);
    mavlink_msg_xap_camera_target_info_decode(&msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);

        memset(&packet2, 0, sizeof(packet2));
    mavlink_msg_xap_camera_target_info_pack(system_id, component_id, &msg , packet1.time_boot_ms , packet1.targetID , packet1.x_offset , packet1.y_offset , packet1.height , packet1.width , packet1.do_rectify , packet1.isTarget );
    mavlink_msg_xap_camera_target_info_decode(&msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);

        memset(&packet2, 0, sizeof(packet2));
    mavlink_msg_xap_camera_target_info_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_boot_ms , packet1.targetID , packet1.x_offset , packet1.y_offset , packet1.height , packet1.width , packet1.do_rectify , packet1.isTarget );
    mavlink_msg_xap_camera_target_info_decode(&msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);

        memset(&packet2, 0, sizeof(packet2));
        mavlink_msg_to_send_buffer(buffer, &msg);
        for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
            comm_send_ch(MAVLINK_COMM_0, buffer[i]);
        }
    mavlink_msg_xap_camera_target_info_decode(last_msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
        
        memset(&packet2, 0, sizeof(packet2));
    mavlink_msg_xap_camera_target_info_send(MAVLINK_COMM_1 , packet1.time_boot_ms , packet1.targetID , packet1.x_offset , packet1.y_offset , packet1.height , packet1.width , packet1.do_rectify , packet1.isTarget );
    mavlink_msg_xap_camera_target_info_decode(last_msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
}

static void mavlink_test_xap_collaborator_ugv_pva_info(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
{
#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
    mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
        if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_XAP_COLLABORATOR_UGV_PVA_INFO >= 256) {
            return;
        }
#endif
    mavlink_message_t msg;
        uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
        uint16_t i;
    mavlink_xap_collaborator_ugv_pva_info_t packet_in = {
        963497464,963497672,963497880,963498088,129.0,157.0,185.0,213.0,241.0,269.0,125,192,3,70,137
    };
    mavlink_xap_collaborator_ugv_pva_info_t packet1, packet2;
        memset(&packet1, 0, sizeof(packet1));
        packet1.time_boot_ms = packet_in.time_boot_ms;
        packet1.latitude = packet_in.latitude;
        packet1.longitude = packet_in.longitude;
        packet1.altitude = packet_in.altitude;
        packet1.velN = packet_in.velN;
        packet1.velE = packet_in.velE;
        packet1.velD = packet_in.velD;
        packet1.roll = packet_in.roll;
        packet1.pitch = packet_in.pitch;
        packet1.yaw = packet_in.yaw;
        packet1.ID = packet_in.ID;
        packet1.poseValid = packet_in.poseValid;
        packet1.velValid = packet_in.velValid;
        packet1.attValid = packet_in.attValid;
        packet1.isTarget = packet_in.isTarget;
        
        
#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
        if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
           // cope with extensions
           memset(MAVLINK_MSG_ID_XAP_COLLABORATOR_UGV_PVA_INFO_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_XAP_COLLABORATOR_UGV_PVA_INFO_MIN_LEN);
        }
#endif
        memset(&packet2, 0, sizeof(packet2));
    mavlink_msg_xap_collaborator_ugv_pva_info_encode(system_id, component_id, &msg, &packet1);
    mavlink_msg_xap_collaborator_ugv_pva_info_decode(&msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);

        memset(&packet2, 0, sizeof(packet2));
    mavlink_msg_xap_collaborator_ugv_pva_info_pack(system_id, component_id, &msg , packet1.time_boot_ms , packet1.ID , packet1.latitude , packet1.longitude , packet1.altitude , packet1.velN , packet1.velE , packet1.velD , packet1.roll , packet1.pitch , packet1.yaw , packet1.poseValid , packet1.velValid , packet1.attValid , packet1.isTarget );
    mavlink_msg_xap_collaborator_ugv_pva_info_decode(&msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);

        memset(&packet2, 0, sizeof(packet2));
    mavlink_msg_xap_collaborator_ugv_pva_info_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_boot_ms , packet1.ID , packet1.latitude , packet1.longitude , packet1.altitude , packet1.velN , packet1.velE , packet1.velD , packet1.roll , packet1.pitch , packet1.yaw , packet1.poseValid , packet1.velValid , packet1.attValid , packet1.isTarget );
    mavlink_msg_xap_collaborator_ugv_pva_info_decode(&msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);

        memset(&packet2, 0, sizeof(packet2));
        mavlink_msg_to_send_buffer(buffer, &msg);
        for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
            comm_send_ch(MAVLINK_COMM_0, buffer[i]);
        }
    mavlink_msg_xap_collaborator_ugv_pva_info_decode(last_msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
        
        memset(&packet2, 0, sizeof(packet2));
    mavlink_msg_xap_collaborator_ugv_pva_info_send(MAVLINK_COMM_1 , packet1.time_boot_ms , packet1.ID , packet1.latitude , packet1.longitude , packet1.altitude , packet1.velN , packet1.velE , packet1.velD , packet1.roll , packet1.pitch , packet1.yaw , packet1.poseValid , packet1.velValid , packet1.attValid , packet1.isTarget );
    mavlink_msg_xap_collaborator_ugv_pva_info_decode(last_msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
}

static void mavlink_test_xap_sbg_status_msg(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
{
#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
    mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
        if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_XAP_SBG_STATUS_MSG >= 256) {
            return;
        }
#endif
    mavlink_message_t msg;
        uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
        uint16_t i;
    mavlink_xap_sbg_status_msg_t packet_in = {
        963497464,963497672,963497880,963498088,18067,187
    };
    mavlink_xap_sbg_status_msg_t packet1, packet2;
        memset(&packet1, 0, sizeof(packet1));
        packet1.time_boot_ms = packet_in.time_boot_ms;
        packet1.com_status = packet_in.com_status;
        packet1.aiding_status = packet_in.aiding_status;
        packet1.up_data = packet_in.up_data;
        packet1.general_status = packet_in.general_status;
        packet1.sbg_id = packet_in.sbg_id;
        
        
#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
        if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
           // cope with extensions
           memset(MAVLINK_MSG_ID_XAP_SBG_STATUS_MSG_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_XAP_SBG_STATUS_MSG_MIN_LEN);
        }
#endif
        memset(&packet2, 0, sizeof(packet2));
    mavlink_msg_xap_sbg_status_msg_encode(system_id, component_id, &msg, &packet1);
    mavlink_msg_xap_sbg_status_msg_decode(&msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);

        memset(&packet2, 0, sizeof(packet2));
    mavlink_msg_xap_sbg_status_msg_pack(system_id, component_id, &msg , packet1.time_boot_ms , packet1.sbg_id , packet1.general_status , packet1.com_status , packet1.aiding_status , packet1.up_data );
    mavlink_msg_xap_sbg_status_msg_decode(&msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);

        memset(&packet2, 0, sizeof(packet2));
    mavlink_msg_xap_sbg_status_msg_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_boot_ms , packet1.sbg_id , packet1.general_status , packet1.com_status , packet1.aiding_status , packet1.up_data );
    mavlink_msg_xap_sbg_status_msg_decode(&msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);

        memset(&packet2, 0, sizeof(packet2));
        mavlink_msg_to_send_buffer(buffer, &msg);
        for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
            comm_send_ch(MAVLINK_COMM_0, buffer[i]);
        }
    mavlink_msg_xap_sbg_status_msg_decode(last_msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
        
        memset(&packet2, 0, sizeof(packet2));
    mavlink_msg_xap_sbg_status_msg_send(MAVLINK_COMM_1 , packet1.time_boot_ms , packet1.sbg_id , packet1.general_status , packet1.com_status , packet1.aiding_status , packet1.up_data );
    mavlink_msg_xap_sbg_status_msg_decode(last_msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
}

static void mavlink_test_xap_sbg_utc_msg(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
{
#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
    mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
        if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_XAP_SBG_UTC_MSG >= 256) {
            return;
        }
#endif
    mavlink_message_t msg;
        uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
        uint16_t i;
    mavlink_xap_sbg_utc_msg_t packet_in = {
        963497464,963497672,963497880,17859,17963,53,120,187,254,65,132
    };
    mavlink_xap_sbg_utc_msg_t packet1, packet2;
        memset(&packet1, 0, sizeof(packet1));
        packet1.time_boot_ms = packet_in.time_boot_ms;
        packet1.nanosec = packet_in.nanosec;
        packet1.gps_tow = packet_in.gps_tow;
        packet1.clock_status = packet_in.clock_status;
        packet1.year = packet_in.year;
        packet1.sbg_id = packet_in.sbg_id;
        packet1.month = packet_in.month;
        packet1.day = packet_in.day;
        packet1.hour = packet_in.hour;
        packet1.min = packet_in.min;
        packet1.sec = packet_in.sec;
        
        
#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
        if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
           // cope with extensions
           memset(MAVLINK_MSG_ID_XAP_SBG_UTC_MSG_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_XAP_SBG_UTC_MSG_MIN_LEN);
        }
#endif
        memset(&packet2, 0, sizeof(packet2));
    mavlink_msg_xap_sbg_utc_msg_encode(system_id, component_id, &msg, &packet1);
    mavlink_msg_xap_sbg_utc_msg_decode(&msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);

        memset(&packet2, 0, sizeof(packet2));
    mavlink_msg_xap_sbg_utc_msg_pack(system_id, component_id, &msg , packet1.time_boot_ms , packet1.sbg_id , packet1.clock_status , packet1.year , packet1.month , packet1.day , packet1.hour , packet1.min , packet1.sec , packet1.nanosec , packet1.gps_tow );
    mavlink_msg_xap_sbg_utc_msg_decode(&msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);

        memset(&packet2, 0, sizeof(packet2));
    mavlink_msg_xap_sbg_utc_msg_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_boot_ms , packet1.sbg_id , packet1.clock_status , packet1.year , packet1.month , packet1.day , packet1.hour , packet1.min , packet1.sec , packet1.nanosec , packet1.gps_tow );
    mavlink_msg_xap_sbg_utc_msg_decode(&msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);

        memset(&packet2, 0, sizeof(packet2));
        mavlink_msg_to_send_buffer(buffer, &msg);
        for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
            comm_send_ch(MAVLINK_COMM_0, buffer[i]);
        }
    mavlink_msg_xap_sbg_utc_msg_decode(last_msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
        
        memset(&packet2, 0, sizeof(packet2));
    mavlink_msg_xap_sbg_utc_msg_send(MAVLINK_COMM_1 , packet1.time_boot_ms , packet1.sbg_id , packet1.clock_status , packet1.year , packet1.month , packet1.day , packet1.hour , packet1.min , packet1.sec , packet1.nanosec , packet1.gps_tow );
    mavlink_msg_xap_sbg_utc_msg_decode(last_msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
}

static void mavlink_test_xap_sbg_imu_data_msg(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
{
#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
    mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
        if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_XAP_SBG_IMU_DATA_MSG >= 256) {
            return;
        }
#endif
    mavlink_message_t msg;
        uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
        uint16_t i;
    mavlink_xap_sbg_imu_data_msg_t packet_in = {
        963497464,45.0,73.0,101.0,129.0,157.0,185.0,213.0,241.0,269.0,297.0,325.0,353.0,381.0,20147,51
    };
    mavlink_xap_sbg_imu_data_msg_t packet1, packet2;
        memset(&packet1, 0, sizeof(packet1));
        packet1.time_boot_ms = packet_in.time_boot_ms;
        packet1.accel_x = packet_in.accel_x;
        packet1.accel_y = packet_in.accel_y;
        packet1.accel_z = packet_in.accel_z;
        packet1.gyro_x = packet_in.gyro_x;
        packet1.gyro_y = packet_in.gyro_y;
        packet1.gyro_z = packet_in.gyro_z;
        packet1.temp = packet_in.temp;
        packet1.delta_vel_x = packet_in.delta_vel_x;
        packet1.delta_vel_y = packet_in.delta_vel_y;
        packet1.delta_vel_z = packet_in.delta_vel_z;
        packet1.delta_angle_x = packet_in.delta_angle_x;
        packet1.delta_angle_y = packet_in.delta_angle_y;
        packet1.delta_angle_z = packet_in.delta_angle_z;
        packet1.imu_status = packet_in.imu_status;
        packet1.sbg_id = packet_in.sbg_id;
        
        
#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
        if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
           // cope with extensions
           memset(MAVLINK_MSG_ID_XAP_SBG_IMU_DATA_MSG_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_XAP_SBG_IMU_DATA_MSG_MIN_LEN);
        }
#endif
        memset(&packet2, 0, sizeof(packet2));
    mavlink_msg_xap_sbg_imu_data_msg_encode(system_id, component_id, &msg, &packet1);
    mavlink_msg_xap_sbg_imu_data_msg_decode(&msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);

        memset(&packet2, 0, sizeof(packet2));
    mavlink_msg_xap_sbg_imu_data_msg_pack(system_id, component_id, &msg , packet1.time_boot_ms , packet1.sbg_id , packet1.imu_status , packet1.accel_x , packet1.accel_y , packet1.accel_z , packet1.gyro_x , packet1.gyro_y , packet1.gyro_z , packet1.temp , packet1.delta_vel_x , packet1.delta_vel_y , packet1.delta_vel_z , packet1.delta_angle_x , packet1.delta_angle_y , packet1.delta_angle_z );
    mavlink_msg_xap_sbg_imu_data_msg_decode(&msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);

        memset(&packet2, 0, sizeof(packet2));
    mavlink_msg_xap_sbg_imu_data_msg_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_boot_ms , packet1.sbg_id , packet1.imu_status , packet1.accel_x , packet1.accel_y , packet1.accel_z , packet1.gyro_x , packet1.gyro_y , packet1.gyro_z , packet1.temp , packet1.delta_vel_x , packet1.delta_vel_y , packet1.delta_vel_z , packet1.delta_angle_x , packet1.delta_angle_y , packet1.delta_angle_z );
    mavlink_msg_xap_sbg_imu_data_msg_decode(&msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);

        memset(&packet2, 0, sizeof(packet2));
        mavlink_msg_to_send_buffer(buffer, &msg);
        for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
            comm_send_ch(MAVLINK_COMM_0, buffer[i]);
        }
    mavlink_msg_xap_sbg_imu_data_msg_decode(last_msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
        
        memset(&packet2, 0, sizeof(packet2));
    mavlink_msg_xap_sbg_imu_data_msg_send(MAVLINK_COMM_1 , packet1.time_boot_ms , packet1.sbg_id , packet1.imu_status , packet1.accel_x , packet1.accel_y , packet1.accel_z , packet1.gyro_x , packet1.gyro_y , packet1.gyro_z , packet1.temp , packet1.delta_vel_x , packet1.delta_vel_y , packet1.delta_vel_z , packet1.delta_angle_x , packet1.delta_angle_y , packet1.delta_angle_z );
    mavlink_msg_xap_sbg_imu_data_msg_decode(last_msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
}

static void mavlink_test_xap_sbg_mag_data_msg(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
{
#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
    mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
        if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_XAP_SBG_MAG_DATA_MSG >= 256) {
            return;
        }
#endif
    mavlink_message_t msg;
        uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
        uint16_t i;
    mavlink_xap_sbg_mag_data_msg_t packet_in = {
        963497464,45.0,73.0,101.0,129.0,157.0,185.0,18691,223
    };
    mavlink_xap_sbg_mag_data_msg_t packet1, packet2;
        memset(&packet1, 0, sizeof(packet1));
        packet1.time_boot_ms = packet_in.time_boot_ms;
        packet1.mag_x = packet_in.mag_x;
        packet1.mag_y = packet_in.mag_y;
        packet1.mag_z = packet_in.mag_z;
        packet1.accel_x = packet_in.accel_x;
        packet1.accel_y = packet_in.accel_y;
        packet1.accel_z = packet_in.accel_z;
        packet1.mag_status = packet_in.mag_status;
        packet1.sbg_id = packet_in.sbg_id;
        
        
#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
        if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
           // cope with extensions
           memset(MAVLINK_MSG_ID_XAP_SBG_MAG_DATA_MSG_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_XAP_SBG_MAG_DATA_MSG_MIN_LEN);
        }
#endif
        memset(&packet2, 0, sizeof(packet2));
    mavlink_msg_xap_sbg_mag_data_msg_encode(system_id, component_id, &msg, &packet1);
    mavlink_msg_xap_sbg_mag_data_msg_decode(&msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);

        memset(&packet2, 0, sizeof(packet2));
    mavlink_msg_xap_sbg_mag_data_msg_pack(system_id, component_id, &msg , packet1.time_boot_ms , packet1.sbg_id , packet1.mag_status , packet1.mag_x , packet1.mag_y , packet1.mag_z , packet1.accel_x , packet1.accel_y , packet1.accel_z );
    mavlink_msg_xap_sbg_mag_data_msg_decode(&msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);

        memset(&packet2, 0, sizeof(packet2));
    mavlink_msg_xap_sbg_mag_data_msg_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_boot_ms , packet1.sbg_id , packet1.mag_status , packet1.mag_x , packet1.mag_y , packet1.mag_z , packet1.accel_x , packet1.accel_y , packet1.accel_z );
    mavlink_msg_xap_sbg_mag_data_msg_decode(&msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);

        memset(&packet2, 0, sizeof(packet2));
        mavlink_msg_to_send_buffer(buffer, &msg);
        for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
            comm_send_ch(MAVLINK_COMM_0, buffer[i]);
        }
    mavlink_msg_xap_sbg_mag_data_msg_decode(last_msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
        
        memset(&packet2, 0, sizeof(packet2));
    mavlink_msg_xap_sbg_mag_data_msg_send(MAVLINK_COMM_1 , packet1.time_boot_ms , packet1.sbg_id , packet1.mag_status , packet1.mag_x , packet1.mag_y , packet1.mag_z , packet1.accel_x , packet1.accel_y , packet1.accel_z );
    mavlink_msg_xap_sbg_mag_data_msg_decode(last_msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
}

static void mavlink_test_xap_sbg_mag_calib_msg(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
{
#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
    mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
        if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_XAP_SBG_MAG_CALIB_MSG >= 256) {
            return;
        }
#endif
    mavlink_message_t msg;
        uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
        uint16_t i;
    mavlink_xap_sbg_mag_calib_msg_t packet_in = {
        963497464,17,{ 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99 }
    };
    mavlink_xap_sbg_mag_calib_msg_t packet1, packet2;
        memset(&packet1, 0, sizeof(packet1));
        packet1.time_boot_ms = packet_in.time_boot_ms;
        packet1.sbg_id = packet_in.sbg_id;
        
        mav_array_memcpy(packet1.buffer, packet_in.buffer, sizeof(uint8_t)*16);
        
#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
        if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
           // cope with extensions
           memset(MAVLINK_MSG_ID_XAP_SBG_MAG_CALIB_MSG_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_XAP_SBG_MAG_CALIB_MSG_MIN_LEN);
        }
#endif
        memset(&packet2, 0, sizeof(packet2));
    mavlink_msg_xap_sbg_mag_calib_msg_encode(system_id, component_id, &msg, &packet1);
    mavlink_msg_xap_sbg_mag_calib_msg_decode(&msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);

        memset(&packet2, 0, sizeof(packet2));
    mavlink_msg_xap_sbg_mag_calib_msg_pack(system_id, component_id, &msg , packet1.time_boot_ms , packet1.sbg_id , packet1.buffer );
    mavlink_msg_xap_sbg_mag_calib_msg_decode(&msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);

        memset(&packet2, 0, sizeof(packet2));
    mavlink_msg_xap_sbg_mag_calib_msg_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_boot_ms , packet1.sbg_id , packet1.buffer );
    mavlink_msg_xap_sbg_mag_calib_msg_decode(&msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);

        memset(&packet2, 0, sizeof(packet2));
        mavlink_msg_to_send_buffer(buffer, &msg);
        for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
            comm_send_ch(MAVLINK_COMM_0, buffer[i]);
        }
    mavlink_msg_xap_sbg_mag_calib_msg_decode(last_msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
        
        memset(&packet2, 0, sizeof(packet2));
    mavlink_msg_xap_sbg_mag_calib_msg_send(MAVLINK_COMM_1 , packet1.time_boot_ms , packet1.sbg_id , packet1.buffer );
    mavlink_msg_xap_sbg_mag_calib_msg_decode(last_msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
}

static void mavlink_test_xap_sbg_ekf_euler_msg(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
{
#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
    mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
        if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_XAP_SBG_EKF_EULER_MSG >= 256) {
            return;
        }
#endif
    mavlink_message_t msg;
        uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
        uint16_t i;
    mavlink_xap_sbg_ekf_euler_msg_t packet_in = {
        963497464,45.0,73.0,101.0,129.0,157.0,185.0,963498920,101
    };
    mavlink_xap_sbg_ekf_euler_msg_t packet1, packet2;
        memset(&packet1, 0, sizeof(packet1));
        packet1.time_boot_ms = packet_in.time_boot_ms;
        packet1.roll = packet_in.roll;
        packet1.pitch = packet_in.pitch;
        packet1.yaw = packet_in.yaw;
        packet1.roll_acc = packet_in.roll_acc;
        packet1.pitch_acc = packet_in.pitch_acc;
        packet1.yaw_acc = packet_in.yaw_acc;
        packet1.solution_status = packet_in.solution_status;
        packet1.sbg_id = packet_in.sbg_id;
        
        
#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
        if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
           // cope with extensions
           memset(MAVLINK_MSG_ID_XAP_SBG_EKF_EULER_MSG_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_XAP_SBG_EKF_EULER_MSG_MIN_LEN);
        }
#endif
        memset(&packet2, 0, sizeof(packet2));
    mavlink_msg_xap_sbg_ekf_euler_msg_encode(system_id, component_id, &msg, &packet1);
    mavlink_msg_xap_sbg_ekf_euler_msg_decode(&msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);

        memset(&packet2, 0, sizeof(packet2));
    mavlink_msg_xap_sbg_ekf_euler_msg_pack(system_id, component_id, &msg , packet1.time_boot_ms , packet1.sbg_id , packet1.roll , packet1.pitch , packet1.yaw , packet1.roll_acc , packet1.pitch_acc , packet1.yaw_acc , packet1.solution_status );
    mavlink_msg_xap_sbg_ekf_euler_msg_decode(&msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);

        memset(&packet2, 0, sizeof(packet2));
    mavlink_msg_xap_sbg_ekf_euler_msg_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_boot_ms , packet1.sbg_id , packet1.roll , packet1.pitch , packet1.yaw , packet1.roll_acc , packet1.pitch_acc , packet1.yaw_acc , packet1.solution_status );
    mavlink_msg_xap_sbg_ekf_euler_msg_decode(&msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);

        memset(&packet2, 0, sizeof(packet2));
        mavlink_msg_to_send_buffer(buffer, &msg);
        for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
            comm_send_ch(MAVLINK_COMM_0, buffer[i]);
        }
    mavlink_msg_xap_sbg_ekf_euler_msg_decode(last_msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
        
        memset(&packet2, 0, sizeof(packet2));
    mavlink_msg_xap_sbg_ekf_euler_msg_send(MAVLINK_COMM_1 , packet1.time_boot_ms , packet1.sbg_id , packet1.roll , packet1.pitch , packet1.yaw , packet1.roll_acc , packet1.pitch_acc , packet1.yaw_acc , packet1.solution_status );
    mavlink_msg_xap_sbg_ekf_euler_msg_decode(last_msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
}

static void mavlink_test_xap_sbg_ekf_quat_msg(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
{
#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
    mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
        if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_XAP_SBG_EKF_QUAT_MSG >= 256) {
            return;
        }
#endif
    mavlink_message_t msg;
        uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
        uint16_t i;
    mavlink_xap_sbg_ekf_quat_msg_t packet_in = {
        963497464,45.0,73.0,101.0,129.0,157.0,185.0,213.0,963499128,113
    };
    mavlink_xap_sbg_ekf_quat_msg_t packet1, packet2;
        memset(&packet1, 0, sizeof(packet1));
        packet1.time_boot_ms = packet_in.time_boot_ms;
        packet1.q0 = packet_in.q0;
        packet1.q1 = packet_in.q1;
        packet1.q2 = packet_in.q2;
        packet1.q3 = packet_in.q3;
        packet1.roll_acc = packet_in.roll_acc;
        packet1.pitch_acc = packet_in.pitch_acc;
        packet1.yaw_acc = packet_in.yaw_acc;
        packet1.solution_status = packet_in.solution_status;
        packet1.sbg_id = packet_in.sbg_id;
        
        
#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
        if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
           // cope with extensions
           memset(MAVLINK_MSG_ID_XAP_SBG_EKF_QUAT_MSG_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_XAP_SBG_EKF_QUAT_MSG_MIN_LEN);
        }
#endif
        memset(&packet2, 0, sizeof(packet2));
    mavlink_msg_xap_sbg_ekf_quat_msg_encode(system_id, component_id, &msg, &packet1);
    mavlink_msg_xap_sbg_ekf_quat_msg_decode(&msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);

        memset(&packet2, 0, sizeof(packet2));
    mavlink_msg_xap_sbg_ekf_quat_msg_pack(system_id, component_id, &msg , packet1.time_boot_ms , packet1.sbg_id , packet1.q0 , packet1.q1 , packet1.q2 , packet1.q3 , packet1.roll_acc , packet1.pitch_acc , packet1.yaw_acc , packet1.solution_status );
    mavlink_msg_xap_sbg_ekf_quat_msg_decode(&msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);

        memset(&packet2, 0, sizeof(packet2));
    mavlink_msg_xap_sbg_ekf_quat_msg_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_boot_ms , packet1.sbg_id , packet1.q0 , packet1.q1 , packet1.q2 , packet1.q3 , packet1.roll_acc , packet1.pitch_acc , packet1.yaw_acc , packet1.solution_status );
    mavlink_msg_xap_sbg_ekf_quat_msg_decode(&msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);

        memset(&packet2, 0, sizeof(packet2));
        mavlink_msg_to_send_buffer(buffer, &msg);
        for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
            comm_send_ch(MAVLINK_COMM_0, buffer[i]);
        }
    mavlink_msg_xap_sbg_ekf_quat_msg_decode(last_msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
        
        memset(&packet2, 0, sizeof(packet2));
    mavlink_msg_xap_sbg_ekf_quat_msg_send(MAVLINK_COMM_1 , packet1.time_boot_ms , packet1.sbg_id , packet1.q0 , packet1.q1 , packet1.q2 , packet1.q3 , packet1.roll_acc , packet1.pitch_acc , packet1.yaw_acc , packet1.solution_status );
    mavlink_msg_xap_sbg_ekf_quat_msg_decode(last_msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
}

static void mavlink_test_xap_sbg_ekf_nav_msg(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
{
#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
    mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
        if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_XAP_SBG_EKF_NAV_MSG >= 256) {
            return;
        }
#endif
    mavlink_message_t msg;
        uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
        uint16_t i;
    mavlink_xap_sbg_ekf_nav_msg_t packet_in = {
        123.0,179.0,235.0,963498712,213.0,241.0,269.0,297.0,325.0,353.0,381.0,409.0,437.0,465.0,963501000,221
    };
    mavlink_xap_sbg_ekf_nav_msg_t packet1, packet2;
        memset(&packet1, 0, sizeof(packet1));
        packet1.latitude = packet_in.latitude;
        packet1.longitude = packet_in.longitude;
        packet1.altitude = packet_in.altitude;
        packet1.time_boot_ms = packet_in.time_boot_ms;
        packet1.velpcity_n = packet_in.velpcity_n;
        packet1.velpcity_e = packet_in.velpcity_e;
        packet1.velpcity_d = packet_in.velpcity_d;
        packet1.velpcity_n_acc = packet_in.velpcity_n_acc;
        packet1.velpcity_e_acc = packet_in.velpcity_e_acc;
        packet1.velpcity_d_acc = packet_in.velpcity_d_acc;
        packet1.undulation = packet_in.undulation;
        packet1.latitude_acc = packet_in.latitude_acc;
        packet1.longitude_acc = packet_in.longitude_acc;
        packet1.altitude_acc = packet_in.altitude_acc;
        packet1.solution_status = packet_in.solution_status;
        packet1.sbg_id = packet_in.sbg_id;
        
        
#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
        if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
           // cope with extensions
           memset(MAVLINK_MSG_ID_XAP_SBG_EKF_NAV_MSG_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_XAP_SBG_EKF_NAV_MSG_MIN_LEN);
        }
#endif
        memset(&packet2, 0, sizeof(packet2));
    mavlink_msg_xap_sbg_ekf_nav_msg_encode(system_id, component_id, &msg, &packet1);
    mavlink_msg_xap_sbg_ekf_nav_msg_decode(&msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);

        memset(&packet2, 0, sizeof(packet2));
    mavlink_msg_xap_sbg_ekf_nav_msg_pack(system_id, component_id, &msg , packet1.time_boot_ms , packet1.sbg_id , packet1.velpcity_n , packet1.velpcity_e , packet1.velpcity_d , packet1.velpcity_n_acc , packet1.velpcity_e_acc , packet1.velpcity_d_acc , packet1.latitude , packet1.longitude , packet1.altitude , packet1.undulation , packet1.latitude_acc , packet1.longitude_acc , packet1.altitude_acc , packet1.solution_status );
    mavlink_msg_xap_sbg_ekf_nav_msg_decode(&msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);

        memset(&packet2, 0, sizeof(packet2));
    mavlink_msg_xap_sbg_ekf_nav_msg_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_boot_ms , packet1.sbg_id , packet1.velpcity_n , packet1.velpcity_e , packet1.velpcity_d , packet1.velpcity_n_acc , packet1.velpcity_e_acc , packet1.velpcity_d_acc , packet1.latitude , packet1.longitude , packet1.altitude , packet1.undulation , packet1.latitude_acc , packet1.longitude_acc , packet1.altitude_acc , packet1.solution_status );
    mavlink_msg_xap_sbg_ekf_nav_msg_decode(&msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);

        memset(&packet2, 0, sizeof(packet2));
        mavlink_msg_to_send_buffer(buffer, &msg);
        for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
            comm_send_ch(MAVLINK_COMM_0, buffer[i]);
        }
    mavlink_msg_xap_sbg_ekf_nav_msg_decode(last_msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
        
        memset(&packet2, 0, sizeof(packet2));
    mavlink_msg_xap_sbg_ekf_nav_msg_send(MAVLINK_COMM_1 , packet1.time_boot_ms , packet1.sbg_id , packet1.velpcity_n , packet1.velpcity_e , packet1.velpcity_d , packet1.velpcity_n_acc , packet1.velpcity_e_acc , packet1.velpcity_d_acc , packet1.latitude , packet1.longitude , packet1.altitude , packet1.undulation , packet1.latitude_acc , packet1.longitude_acc , packet1.altitude_acc , packet1.solution_status );
    mavlink_msg_xap_sbg_ekf_nav_msg_decode(last_msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
}

static void mavlink_test_xap_sbg_gps_vel_msg(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
{
#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
    mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
        if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_XAP_SBG_GPS_VEL_MSG >= 256) {
            return;
        }
#endif
    mavlink_message_t msg;
        uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
        uint16_t i;
    mavlink_xap_sbg_gps_vel_msg_t packet_in = {
        963497464,963497672,963497880,101.0,129.0,157.0,185.0,213.0,241.0,269.0,297.0,137,204
    };
    mavlink_xap_sbg_gps_vel_msg_t packet1, packet2;
        memset(&packet1, 0, sizeof(packet1));
        packet1.time_boot_ms = packet_in.time_boot_ms;
        packet1.gps_vel_status = packet_in.gps_vel_status;
        packet1.gps_tow = packet_in.gps_tow;
        packet1.vel_n = packet_in.vel_n;
        packet1.vel_e = packet_in.vel_e;
        packet1.vel_d = packet_in.vel_d;
        packet1.vel_acc_n = packet_in.vel_acc_n;
        packet1.vel_acc_e = packet_in.vel_acc_e;
        packet1.vel_acc_d = packet_in.vel_acc_d;
        packet1.course = packet_in.course;
        packet1.course_acc = packet_in.course_acc;
        packet1.sbg_id = packet_in.sbg_id;
        packet1.gps_id = packet_in.gps_id;
        
        
#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
        if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
           // cope with extensions
           memset(MAVLINK_MSG_ID_XAP_SBG_GPS_VEL_MSG_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_XAP_SBG_GPS_VEL_MSG_MIN_LEN);
        }
#endif
        memset(&packet2, 0, sizeof(packet2));
    mavlink_msg_xap_sbg_gps_vel_msg_encode(system_id, component_id, &msg, &packet1);
    mavlink_msg_xap_sbg_gps_vel_msg_decode(&msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);

        memset(&packet2, 0, sizeof(packet2));
    mavlink_msg_xap_sbg_gps_vel_msg_pack(system_id, component_id, &msg , packet1.time_boot_ms , packet1.sbg_id , packet1.gps_id , packet1.gps_vel_status , packet1.gps_tow , packet1.vel_n , packet1.vel_e , packet1.vel_d , packet1.vel_acc_n , packet1.vel_acc_e , packet1.vel_acc_d , packet1.course , packet1.course_acc );
    mavlink_msg_xap_sbg_gps_vel_msg_decode(&msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);

        memset(&packet2, 0, sizeof(packet2));
    mavlink_msg_xap_sbg_gps_vel_msg_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_boot_ms , packet1.sbg_id , packet1.gps_id , packet1.gps_vel_status , packet1.gps_tow , packet1.vel_n , packet1.vel_e , packet1.vel_d , packet1.vel_acc_n , packet1.vel_acc_e , packet1.vel_acc_d , packet1.course , packet1.course_acc );
    mavlink_msg_xap_sbg_gps_vel_msg_decode(&msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);

        memset(&packet2, 0, sizeof(packet2));
        mavlink_msg_to_send_buffer(buffer, &msg);
        for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
            comm_send_ch(MAVLINK_COMM_0, buffer[i]);
        }
    mavlink_msg_xap_sbg_gps_vel_msg_decode(last_msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
        
        memset(&packet2, 0, sizeof(packet2));
    mavlink_msg_xap_sbg_gps_vel_msg_send(MAVLINK_COMM_1 , packet1.time_boot_ms , packet1.sbg_id , packet1.gps_id , packet1.gps_vel_status , packet1.gps_tow , packet1.vel_n , packet1.vel_e , packet1.vel_d , packet1.vel_acc_n , packet1.vel_acc_e , packet1.vel_acc_d , packet1.course , packet1.course_acc );
    mavlink_msg_xap_sbg_gps_vel_msg_decode(last_msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
}

static void mavlink_test_xap_sbg_gps_pos_msg(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
{
#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
    mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
        if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_XAP_SBG_GPS_POS_MSG >= 256) {
            return;
        }
#endif
    mavlink_message_t msg;
        uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
        uint16_t i;
    mavlink_xap_sbg_gps_pos_msg_t packet_in = {
        123.0,179.0,235.0,963498712,963498920,963499128,269.0,297.0,325.0,353.0,19939,20043,173,240,51
    };
    mavlink_xap_sbg_gps_pos_msg_t packet1, packet2;
        memset(&packet1, 0, sizeof(packet1));
        packet1.lat = packet_in.lat;
        packet1.longit = packet_in.longit;
        packet1.alt = packet_in.alt;
        packet1.time_boot_ms = packet_in.time_boot_ms;
        packet1.gps_pos_status = packet_in.gps_pos_status;
        packet1.gps_tow = packet_in.gps_tow;
        packet1.undulation = packet_in.undulation;
        packet1.pos_acc_lat = packet_in.pos_acc_lat;
        packet1.pos_acc_longit = packet_in.pos_acc_longit;
        packet1.pos_acc_alt = packet_in.pos_acc_alt;
        packet1.base_station_id = packet_in.base_station_id;
        packet1.diff_age = packet_in.diff_age;
        packet1.sbg_id = packet_in.sbg_id;
        packet1.gps_id = packet_in.gps_id;
        packet1.num_sv_used = packet_in.num_sv_used;
        
        
#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
        if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
           // cope with extensions
           memset(MAVLINK_MSG_ID_XAP_SBG_GPS_POS_MSG_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_XAP_SBG_GPS_POS_MSG_MIN_LEN);
        }
#endif
        memset(&packet2, 0, sizeof(packet2));
    mavlink_msg_xap_sbg_gps_pos_msg_encode(system_id, component_id, &msg, &packet1);
    mavlink_msg_xap_sbg_gps_pos_msg_decode(&msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);

        memset(&packet2, 0, sizeof(packet2));
    mavlink_msg_xap_sbg_gps_pos_msg_pack(system_id, component_id, &msg , packet1.time_boot_ms , packet1.sbg_id , packet1.gps_id , packet1.gps_pos_status , packet1.gps_tow , packet1.lat , packet1.longit , packet1.alt , packet1.undulation , packet1.pos_acc_lat , packet1.pos_acc_longit , packet1.pos_acc_alt , packet1.num_sv_used , packet1.base_station_id , packet1.diff_age );
    mavlink_msg_xap_sbg_gps_pos_msg_decode(&msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);

        memset(&packet2, 0, sizeof(packet2));
    mavlink_msg_xap_sbg_gps_pos_msg_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_boot_ms , packet1.sbg_id , packet1.gps_id , packet1.gps_pos_status , packet1.gps_tow , packet1.lat , packet1.longit , packet1.alt , packet1.undulation , packet1.pos_acc_lat , packet1.pos_acc_longit , packet1.pos_acc_alt , packet1.num_sv_used , packet1.base_station_id , packet1.diff_age );
    mavlink_msg_xap_sbg_gps_pos_msg_decode(&msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);

        memset(&packet2, 0, sizeof(packet2));
        mavlink_msg_to_send_buffer(buffer, &msg);
        for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
            comm_send_ch(MAVLINK_COMM_0, buffer[i]);
        }
    mavlink_msg_xap_sbg_gps_pos_msg_decode(last_msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
        
        memset(&packet2, 0, sizeof(packet2));
    mavlink_msg_xap_sbg_gps_pos_msg_send(MAVLINK_COMM_1 , packet1.time_boot_ms , packet1.sbg_id , packet1.gps_id , packet1.gps_pos_status , packet1.gps_tow , packet1.lat , packet1.longit , packet1.alt , packet1.undulation , packet1.pos_acc_lat , packet1.pos_acc_longit , packet1.pos_acc_alt , packet1.num_sv_used , packet1.base_station_id , packet1.diff_age );
    mavlink_msg_xap_sbg_gps_pos_msg_decode(last_msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
}

static void mavlink_test_xap_sbg_gps_hdt_msg(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
{
#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
    mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
        if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_XAP_SBG_GPS_HDT_MSG >= 256) {
            return;
        }
#endif
    mavlink_message_t msg;
        uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
        uint16_t i;
    mavlink_xap_sbg_gps_hdt_msg_t packet_in = {
        963497464,963497672,73.0,101.0,129.0,157.0,18483,211,22
    };
    mavlink_xap_sbg_gps_hdt_msg_t packet1, packet2;
        memset(&packet1, 0, sizeof(packet1));
        packet1.time_boot_ms = packet_in.time_boot_ms;
        packet1.gps_tow = packet_in.gps_tow;
        packet1.gps_true_heading = packet_in.gps_true_heading;
        packet1.gps_true_heading_acc = packet_in.gps_true_heading_acc;
        packet1.gps_pitch = packet_in.gps_pitch;
        packet1.gps_pitch_acc = packet_in.gps_pitch_acc;
        packet1.gps_hdt_status = packet_in.gps_hdt_status;
        packet1.sbg_id = packet_in.sbg_id;
        packet1.gps_id = packet_in.gps_id;
        
        
#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
        if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
           // cope with extensions
           memset(MAVLINK_MSG_ID_XAP_SBG_GPS_HDT_MSG_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_XAP_SBG_GPS_HDT_MSG_MIN_LEN);
        }
#endif
        memset(&packet2, 0, sizeof(packet2));
    mavlink_msg_xap_sbg_gps_hdt_msg_encode(system_id, component_id, &msg, &packet1);
    mavlink_msg_xap_sbg_gps_hdt_msg_decode(&msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);

        memset(&packet2, 0, sizeof(packet2));
    mavlink_msg_xap_sbg_gps_hdt_msg_pack(system_id, component_id, &msg , packet1.time_boot_ms , packet1.sbg_id , packet1.gps_id , packet1.gps_hdt_status , packet1.gps_tow , packet1.gps_true_heading , packet1.gps_true_heading_acc , packet1.gps_pitch , packet1.gps_pitch_acc );
    mavlink_msg_xap_sbg_gps_hdt_msg_decode(&msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);

        memset(&packet2, 0, sizeof(packet2));
    mavlink_msg_xap_sbg_gps_hdt_msg_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_boot_ms , packet1.sbg_id , packet1.gps_id , packet1.gps_hdt_status , packet1.gps_tow , packet1.gps_true_heading , packet1.gps_true_heading_acc , packet1.gps_pitch , packet1.gps_pitch_acc );
    mavlink_msg_xap_sbg_gps_hdt_msg_decode(&msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);

        memset(&packet2, 0, sizeof(packet2));
        mavlink_msg_to_send_buffer(buffer, &msg);
        for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
            comm_send_ch(MAVLINK_COMM_0, buffer[i]);
        }
    mavlink_msg_xap_sbg_gps_hdt_msg_decode(last_msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
        
        memset(&packet2, 0, sizeof(packet2));
    mavlink_msg_xap_sbg_gps_hdt_msg_send(MAVLINK_COMM_1 , packet1.time_boot_ms , packet1.sbg_id , packet1.gps_id , packet1.gps_hdt_status , packet1.gps_tow , packet1.gps_true_heading , packet1.gps_true_heading_acc , packet1.gps_pitch , packet1.gps_pitch_acc );
    mavlink_msg_xap_sbg_gps_hdt_msg_decode(last_msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
}

static void mavlink_test_xap_sbg_pressure_msg(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
{
#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
    mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
        if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_XAP_SBG_PRESSURE_MSG >= 256) {
            return;
        }
#endif
    mavlink_message_t msg;
        uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
        uint16_t i;
    mavlink_xap_sbg_pressure_msg_t packet_in = {
        963497464,45.0,73.0,17859,175
    };
    mavlink_xap_sbg_pressure_msg_t packet1, packet2;
        memset(&packet1, 0, sizeof(packet1));
        packet1.time_boot_ms = packet_in.time_boot_ms;
        packet1.pressure = packet_in.pressure;
        packet1.altitude = packet_in.altitude;
        packet1.pressure_status = packet_in.pressure_status;
        packet1.sbg_id = packet_in.sbg_id;
        
        
#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
        if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
           // cope with extensions
           memset(MAVLINK_MSG_ID_XAP_SBG_PRESSURE_MSG_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_XAP_SBG_PRESSURE_MSG_MIN_LEN);
        }
#endif
        memset(&packet2, 0, sizeof(packet2));
    mavlink_msg_xap_sbg_pressure_msg_encode(system_id, component_id, &msg, &packet1);
    mavlink_msg_xap_sbg_pressure_msg_decode(&msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);

        memset(&packet2, 0, sizeof(packet2));
    mavlink_msg_xap_sbg_pressure_msg_pack(system_id, component_id, &msg , packet1.time_boot_ms , packet1.sbg_id , packet1.pressure_status , packet1.pressure , packet1.altitude );
    mavlink_msg_xap_sbg_pressure_msg_decode(&msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);

        memset(&packet2, 0, sizeof(packet2));
    mavlink_msg_xap_sbg_pressure_msg_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_boot_ms , packet1.sbg_id , packet1.pressure_status , packet1.pressure , packet1.altitude );
    mavlink_msg_xap_sbg_pressure_msg_decode(&msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);

        memset(&packet2, 0, sizeof(packet2));
        mavlink_msg_to_send_buffer(buffer, &msg);
        for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
            comm_send_ch(MAVLINK_COMM_0, buffer[i]);
        }
    mavlink_msg_xap_sbg_pressure_msg_decode(last_msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
        
        memset(&packet2, 0, sizeof(packet2));
    mavlink_msg_xap_sbg_pressure_msg_send(MAVLINK_COMM_1 , packet1.time_boot_ms , packet1.sbg_id , packet1.pressure_status , packet1.pressure , packet1.altitude );
    mavlink_msg_xap_sbg_pressure_msg_decode(last_msg, &packet2);
        MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
}

static void mavlink_test_x_autopilot(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
{
    mavlink_test_xap_msg(system_id, component_id, last_msg);
    mavlink_test_xap_aruco(system_id, component_id, last_msg);
    mavlink_test_xap_camera_target_info(system_id, component_id, last_msg);
    mavlink_test_xap_collaborator_ugv_pva_info(system_id, component_id, last_msg);
    mavlink_test_xap_sbg_status_msg(system_id, component_id, last_msg);
    mavlink_test_xap_sbg_utc_msg(system_id, component_id, last_msg);
    mavlink_test_xap_sbg_imu_data_msg(system_id, component_id, last_msg);
    mavlink_test_xap_sbg_mag_data_msg(system_id, component_id, last_msg);
    mavlink_test_xap_sbg_mag_calib_msg(system_id, component_id, last_msg);
    mavlink_test_xap_sbg_ekf_euler_msg(system_id, component_id, last_msg);
    mavlink_test_xap_sbg_ekf_quat_msg(system_id, component_id, last_msg);
    mavlink_test_xap_sbg_ekf_nav_msg(system_id, component_id, last_msg);
    mavlink_test_xap_sbg_gps_vel_msg(system_id, component_id, last_msg);
    mavlink_test_xap_sbg_gps_pos_msg(system_id, component_id, last_msg);
    mavlink_test_xap_sbg_gps_hdt_msg(system_id, component_id, last_msg);
    mavlink_test_xap_sbg_pressure_msg(system_id, component_id, last_msg);
}

#ifdef __cplusplus
}
#endif // __cplusplus
#endif // X_AUTOPILOT_TESTSUITE_H
